home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / nose / suite.py < prev    next >
Text File  |  2009-05-13  |  21KB  |  575 lines
  1. """
  2. Test Suites
  3. -----------
  4.  
  5. Provides a LazySuite, which is a suite whose test list is a generator
  6. function, and ContextSuite,which can run fixtures (setup/teardown
  7. functions or methods) for the context that contains its tests.
  8.  
  9. """
  10. from __future__ import generators
  11.  
  12. import logging
  13. import sys
  14. import unittest
  15. from nose.case import Test
  16. from nose.config import Config
  17. from nose.proxy import ResultProxyFactory
  18. from nose.util import isclass, resolve_name, try_run
  19.  
  20. if sys.platform == 'cli':
  21.     import clr
  22.     clr.AddReference("IronPython")
  23.     from IronPython.Runtime.Exceptions import StringException
  24.  
  25. log = logging.getLogger(__name__)
  26. #log.setLevel(logging.DEBUG)
  27.  
  28. # Singleton for default value -- see ContextSuite.__init__ below
  29. _def = object()
  30.  
  31.  
  32. class MixedContextError(Exception):
  33.     """Error raised when a context suite sees tests from more than
  34.     one context.
  35.     """
  36.     pass
  37.  
  38.  
  39. class LazySuite(unittest.TestSuite):
  40.     """A suite that may use a generator as its list of tests
  41.     """
  42.     def __init__(self, tests=()):
  43.         """Initialize the suite. tests may be an iterable or a generator
  44.         """
  45.         self._set_tests(tests)
  46.                 
  47.     def __iter__(self):
  48.         return iter(self._tests)
  49.         
  50.     def __repr__(self):
  51.         return "<%s tests=generator (%s)>" % (
  52.             unittest._strclass(self.__class__), id(self))
  53.  
  54.     def __hash__(self):
  55.         return object.__hash__(self)
  56.     
  57.     __str__ = __repr__
  58.  
  59.     def addTest(self, test):
  60.         self._precache.append(test)
  61.  
  62.     def __nonzero__(self):
  63.         log.debug("tests in %s?", id(self))
  64.         if self._precache:
  65.             return True
  66.         if self.test_generator is None:
  67.             return False
  68.         try:
  69.             test = self.test_generator.next()
  70.             if test is not None:
  71.                 self._precache.append(test)
  72.                 return True
  73.         except StopIteration:
  74.             pass
  75.         return False
  76.  
  77.     def _get_tests(self):
  78.         log.debug("precache is %s", self._precache)
  79.         for test in self._precache:
  80.             yield test
  81.         if self.test_generator is None:
  82.             return
  83.         for test in self.test_generator:
  84.             yield test
  85.  
  86.     def _set_tests(self, tests):
  87.         self._precache = []
  88.         is_suite = isinstance(tests, unittest.TestSuite)
  89.         if callable(tests) and not is_suite:
  90.             self.test_generator = tests()
  91.         elif is_suite:
  92.             # Suites need special treatment: they must be called like
  93.             # tests for their setup/teardown to run (if any)
  94.             self.addTests([tests])
  95.             self.test_generator = None
  96.         else:
  97.             self.addTests(tests)
  98.             self.test_generator = None
  99.  
  100.     _tests = property(_get_tests, _set_tests, None,
  101.                       "Access the tests in this suite. Access is through a "
  102.                       "generator, so iteration may not be repeatable.")
  103.  
  104.         
  105. class ContextSuite(LazySuite):
  106.     """A suite with context.
  107.  
  108.     A ContextSuite executes fixtures (setup and teardown functions or
  109.     methods) for the context containing its tests.
  110.  
  111.     The context may be explicitly passed. If it is not, a context (or
  112.     nested set of contexts) will be constructed by examining the tests
  113.     in the suite.
  114.     """    
  115.     failureException = unittest.TestCase.failureException
  116.     was_setup = False
  117.     was_torndown = False
  118.     classSetup = ('setup_class', 'setup_all', 'setupClass', 'setupAll',
  119.                      'setUpClass', 'setUpAll')
  120.     classTeardown = ('teardown_class', 'teardown_all', 'teardownClass',
  121.                      'teardownAll', 'tearDownClass', 'tearDownAll')
  122.     moduleSetup = ('setup_module', 'setupModule', 'setUpModule', 'setup',
  123.                    'setUp')
  124.     moduleTeardown = ('teardown_module', 'teardownModule', 'tearDownModule',
  125.                       'teardown', 'tearDown')
  126.     packageSetup = ('setup_package', 'setupPackage', 'setUpPackage')
  127.     packageTeardown = ('teardown_package', 'teardownPackage',
  128.                        'tearDownPackage')
  129.     
  130.     def __init__(self, tests=(), context=None, factory=None,
  131.                  config=None, resultProxy=None, can_split=True):
  132.         log.debug("Context suite for %s (%s) (%s)", tests, context, id(self))
  133.         self.context = context
  134.         self.factory = factory
  135.         if config is None:
  136.             config = Config()
  137.         self.config = config
  138.         self.resultProxy = resultProxy
  139.         self.has_run = False
  140.         self.can_split = can_split
  141.         LazySuite.__init__(self, tests)
  142.  
  143.     def __repr__(self):
  144.         return "<%s context=%s>" % (
  145.             unittest._strclass(self.__class__),
  146.             getattr(self.context, '__name__', self.context))
  147.     __str__ = __repr__
  148.  
  149.     def __hash__(self):
  150.         return object.__hash__(self)
  151.  
  152.     # 2.3 compat -- force 2.4 call sequence
  153.     def __call__(self, *arg, **kw):
  154.         return self.run(*arg, **kw)
  155.  
  156.     def exc_info(self):
  157.         """Hook for replacing error tuple output
  158.         """
  159.         return sys.exc_info()
  160.     
  161.     def _exc_info(self):
  162.         """Bottleneck to fix up IronPython string exceptions
  163.         """
  164.         e = self.exc_info()
  165.         if sys.platform == 'cli':
  166.             if isinstance(e[0], StringException):
  167.                 # IronPython throws these StringExceptions, but
  168.                 # traceback checks type(etype) == str. Make a real
  169.                 # string here.
  170.                 e = (str(e[0]), e[1], e[2])
  171.  
  172.         return e
  173.  
  174.     def run(self, result):
  175.         """Run tests in suite inside of suite fixtures.
  176.         """
  177.         # proxy the result for myself
  178.         if self.resultProxy:
  179.             result, orig = self.resultProxy(result, self), result
  180.         else:
  181.             result, orig = result, result
  182.         try:
  183.             self.setUp()
  184.         except KeyboardInterrupt:
  185.             raise
  186.         except:
  187.             result.addError(self, self._exc_info())
  188.             return
  189.         try:
  190.             for test in self._tests:
  191.                 if result.shouldStop:
  192.                     log.debug("stopping")
  193.                     break
  194.                 # each nose.case.Test will create its own result proxy
  195.                 # so the cases need the original result, to avoid proxy
  196.                 # chains
  197.                 test(orig)
  198.         finally:
  199.             self.has_run = True
  200.             try:
  201.                 self.tearDown()
  202.             except KeyboardInterrupt:
  203.                 raise
  204.             except:
  205.                 result.addError(self, self._exc_info())
  206.  
  207.     def hasFixtures(self, ctx_callback=None):
  208.         context = self.context
  209.         if context is None:
  210.             return False
  211.         if self.implementsAnyFixture(context, ctx_callback=ctx_callback):
  212.             return True
  213.         # My context doesn't have any, but its ancestors might
  214.         factory = self.factory
  215.         if factory:
  216.             ancestors = factory.context.get(self, [])
  217.             for ancestor in ancestors:
  218.                 if self.implementsAnyFixture(
  219.                     ancestor, ctx_callback=ctx_callback):
  220.                     return True
  221.         return False
  222.  
  223.     def implementsAnyFixture(self, context, ctx_callback):
  224.         if isclass(context):
  225.             names = self.classSetup + self.classTeardown
  226.         else:
  227.             names = self.moduleSetup + self.moduleTeardown
  228.             if hasattr(context, '__path__'):
  229.                 names += self.packageSetup + self.packageTeardown
  230.         # If my context has any fixture attribute, I have fixtures
  231.         fixt = False
  232.         for m in names:
  233.             if hasattr(context, m):
  234.                 fixt = True
  235.                 break
  236.         if ctx_callback is None:
  237.             return fixt
  238.         return ctx_callback(context, fixt)
  239.     
  240.     def setUp(self):
  241.         log.debug("suite %s setUp called, tests: %s", id(self), self._tests)
  242.         if not self:
  243.             # I have no tests
  244.             log.debug("suite %s has no tests", id(self))
  245.             return
  246.         if self.was_setup:
  247.             log.debug("suite %s already set up", id(self))
  248.             return
  249.         context = self.context
  250.         if context is None:
  251.             return
  252.         # before running my own context's setup, I need to
  253.         # ask the factory if my context's contexts' setups have been run
  254.         factory = self.factory
  255.         if factory:
  256.             # get a copy, since we'll be destroying it as we go
  257.             ancestors = factory.context.get(self, [])[:]
  258.             while ancestors:
  259.                 ancestor = ancestors.pop()
  260.                 log.debug("ancestor %s may need setup", ancestor)
  261.                 if ancestor in factory.was_setup:
  262.                     continue
  263.                 log.debug("ancestor %s does need setup", ancestor)
  264.                 self.setupContext(ancestor)
  265.             if not context in factory.was_setup:
  266.                 self.setupContext(context)
  267.         else:
  268.             self.setupContext(context)
  269.         self.was_setup = True
  270.         log.debug("completed suite setup")
  271.  
  272.     def setupContext(self, context):
  273.         self.config.plugins.startContext(context)
  274.         log.debug("%s setup context %s", self, context)
  275.         if self.factory:
  276.             if context in self.factory.was_setup:
  277.                 return
  278.             # note that I ran the setup for this context, so that I'll run
  279.             # the teardown in my teardown
  280.             self.factory.was_setup[context] = self
  281.         if isclass(context):
  282.             names = self.classSetup
  283.         else:
  284.             names = self.moduleSetup
  285.             if hasattr(context, '__path__'):
  286.                 names = self.packageSetup + names
  287.         try_run(context, names)
  288.  
  289.     def shortDescription(self):
  290.         if self.context is None:
  291.             return "test suite"
  292.         return "test suite for %s" % self.context
  293.  
  294.     def tearDown(self):
  295.         log.debug('context teardown')
  296.         if not self.was_setup or self.was_torndown:
  297.             log.debug(
  298.                 "No reason to teardown (was_setup? %s was_torndown? %s)"
  299.                 % (self.was_setup, self.was_torndown))
  300.             return
  301.         self.was_torndown = True
  302.         context = self.context
  303.         if context is None:
  304.             log.debug("No context to tear down")
  305.             return
  306.  
  307.         # for each ancestor... if the ancestor was setup
  308.         # and I did the setup, I can do teardown
  309.         factory = self.factory
  310.         if factory:
  311.             ancestors = factory.context.get(self, []) + [context]
  312.             for ancestor in ancestors:
  313.                 log.debug('ancestor %s may need teardown', ancestor)
  314.                 if not ancestor in factory.was_setup:
  315.                     log.debug('ancestor %s was not setup', ancestor)
  316.                     continue
  317.                 if ancestor in factory.was_torndown:
  318.                     log.debug('ancestor %s already torn down', ancestor)
  319.                     continue
  320.                 setup = factory.was_setup[ancestor]
  321.                 log.debug("%s setup ancestor %s", setup, ancestor)
  322.                 if setup is self:
  323.                     self.teardownContext(ancestor)
  324.         else:
  325.             self.teardownContext(context)
  326.         
  327.     def teardownContext(self, context):
  328.         log.debug("%s teardown context %s", self, context)
  329.         if self.factory:
  330.             if context in self.factory.was_torndown:
  331.                 return
  332.             self.factory.was_torndown[context] = self
  333.         if isclass(context):
  334.             names = self.classTeardown
  335.         else:
  336.             names = self.moduleTeardown
  337.             if hasattr(context, '__path__'):
  338.                 names = self.packageTeardown + names
  339.         try_run(context, names)
  340.         self.config.plugins.stopContext(context)
  341.  
  342.     # FIXME the wrapping has to move to the factory?
  343.     def _get_wrapped_tests(self):
  344.         for test in self._get_tests():
  345.             if isinstance(test, Test) or isinstance(test, unittest.TestSuite):
  346.                 yield test
  347.             else:
  348.                 yield Test(test,
  349.                            config=self.config,
  350.                            resultProxy=self.resultProxy)
  351.  
  352.     _tests = property(_get_wrapped_tests, LazySuite._set_tests, None,
  353.                       "Access the tests in this suite. Tests are returned "
  354.                       "inside of a context wrapper.")
  355.  
  356.  
  357. class ContextSuiteFactory(object):
  358.     """Factory for ContextSuites. Called with a collection of tests,
  359.     the factory decides on a hierarchy of contexts by introspecting
  360.     the collection or the tests themselves to find the objects
  361.     containing the test objects. It always returns one suite, but that
  362.     suite may consist of a hierarchy of nested suites.
  363.     """
  364.     suiteClass = ContextSuite
  365.     def __init__(self, config=None, suiteClass=None, resultProxy=_def):
  366.         if config is None:
  367.             config = Config()
  368.         self.config = config
  369.         if suiteClass is not None:
  370.             self.suiteClass = suiteClass
  371.         # Using a singleton to represent default instead of None allows
  372.         # passing resultProxy=None to turn proxying off.
  373.         if resultProxy is _def:
  374.             resultProxy = ResultProxyFactory(config=config)
  375.         self.resultProxy = resultProxy
  376.         self.suites = {}
  377.         self.context = {}
  378.         self.was_setup = {}
  379.         self.was_torndown = {}
  380.  
  381.     def __call__(self, tests, **kw):
  382.         """Return ``ContextSuite`` for tests. ``tests`` may either
  383.         be a callable (in which case the resulting ContextSuite will
  384.         have no parent context and be evaluated lazily) or an
  385.         iterable. In that case the tests will wrapped in
  386.         nose.case.Test, be examined and the context of each found and a
  387.         suite of suites returned, organized into a stack with the
  388.         outermost suites belonging to the outermost contexts.
  389.         """
  390.         log.debug("Create suite for %s", tests)
  391.         context = kw.pop('context', getattr(tests, 'context', None))
  392.         log.debug("tests %s context %s", tests, context)
  393.         if context is None:
  394.             tests = self.wrapTests(tests)
  395.             try:
  396.                 context = self.findContext(tests)
  397.             except MixedContextError:
  398.                 return self.makeSuite(self.mixedSuites(tests), None, **kw)
  399.         return self.makeSuite(tests, context, **kw)
  400.         
  401.     def ancestry(self, context):
  402.         """Return the ancestry of the context (that is, all of the
  403.         packages and modules containing the context), in order of
  404.         descent with the outermost ancestor last.
  405.         This method is a generator.
  406.         """
  407.         log.debug("get ancestry %s", context)
  408.         if context is None:
  409.             return
  410.         # Methods include reference to module they are defined in, we
  411.         # don't want that, instead want the module the class is in now
  412.         # (classes are re-ancestored elsewhere).
  413.         if hasattr(context, 'im_class'):
  414.             context = context.im_class
  415.         if hasattr(context, '__module__'):
  416.             ancestors = context.__module__.split('.')
  417.         elif hasattr(context, '__name__'):
  418.             ancestors = context.__name__.split('.')[:-1]
  419.         else:
  420.             raise TypeError("%s has no ancestors?" % context)
  421.         while ancestors:
  422.             log.debug(" %s ancestors %s", context, ancestors)
  423.             yield resolve_name('.'.join(ancestors))                
  424.             ancestors.pop()
  425.  
  426.     def findContext(self, tests):
  427.         if callable(tests) or isinstance(tests, unittest.TestSuite):
  428.             return None
  429.         context = None
  430.         for test in tests:
  431.             # Don't look at suites for contexts, only tests
  432.             ctx = getattr(test, 'context', None)
  433.             if ctx is None:
  434.                 continue
  435.             if context is None:
  436.                 context = ctx
  437.             elif context != ctx:
  438.                 raise MixedContextError(
  439.                     "Tests with different contexts in same suite! %s != %s"
  440.                     % (context, ctx))
  441.         return context
  442.  
  443.     def makeSuite(self, tests, context, **kw):
  444.         suite = self.suiteClass(
  445.             tests, context=context, config=self.config, factory=self,
  446.             resultProxy=self.resultProxy, **kw)
  447.         if context is not None:
  448.             self.suites.setdefault(context, []).append(suite)
  449.             self.context.setdefault(suite, []).append(context)
  450.             log.debug("suite %s has context %s", suite,
  451.                       getattr(context, '__name__', None))
  452.             for ancestor in self.ancestry(context):
  453.                 self.suites.setdefault(ancestor, []).append(suite)
  454.                 self.context[suite].append(ancestor)
  455.                 log.debug("suite %s has ancestor %s", suite, ancestor.__name__)
  456.         return suite
  457.  
  458.     def mixedSuites(self, tests):
  459.         """The complex case where there are tests that don't all share
  460.         the same context. Groups tests into suites with common ancestors,
  461.         according to the following (essentially tail-recursive) procedure:
  462.  
  463.         Starting with the context of the first test, if it is not
  464.         None, look for tests in the remaining tests that share that
  465.         ancestor. If any are found, group into a suite with that
  466.         ancestor as the context, and replace the current suite with
  467.         that suite. Continue this process for each ancestor of the
  468.         first test, until all ancestors have been processed. At this
  469.         point if any tests remain, recurse with those tests as the
  470.         input, returning a list of the common suite (which may be the
  471.         suite or test we started with, if no common tests were found)
  472.         plus the results of recursion.
  473.         """
  474.         if not tests:
  475.             return []
  476.         head = tests.pop(0)
  477.         if not tests:
  478.             return [head] # short circuit when none are left to combine
  479.         suite = head # the common ancestry suite, so far
  480.         tail = tests[:]
  481.         context = getattr(head, 'context', None)
  482.         if context is not None:
  483.             ancestors = [context] + [a for a in self.ancestry(context)]
  484.             for ancestor in ancestors:
  485.                 common = [suite] # tests with ancestor in common, so far
  486.                 remain = [] # tests that remain to be processed
  487.                 for test in tail:
  488.                     found_common = False
  489.                     test_ctx = getattr(test, 'context', None)
  490.                     if test_ctx is None:
  491.                         remain.append(test)
  492.                         continue
  493.                     if test_ctx is ancestor:
  494.                         common.append(test)
  495.                         continue         
  496.                     for test_ancestor in self.ancestry(test_ctx):
  497.                         if test_ancestor is ancestor:
  498.                             common.append(test)
  499.                             found_common = True
  500.                             break
  501.                     if not found_common:
  502.                         remain.append(test)
  503.                 if common:
  504.                     suite = self.makeSuite(common, ancestor)
  505.                 tail = remain
  506.         return [suite] + self.mixedSuites(tail)
  507.             
  508.     def wrapTests(self, tests):
  509.         log.debug("wrap %s", tests)
  510.         if callable(tests) or isinstance(tests, unittest.TestSuite):
  511.             log.debug("I won't wrap")
  512.             return tests
  513.         wrapped = []
  514.         for test in tests:
  515.             log.debug("wrapping %s", test)
  516.             if isinstance(test, Test) or isinstance(test, unittest.TestSuite):
  517.                 wrapped.append(test)
  518.             elif isinstance(test, ContextList):
  519.                 wrapped.append(self.makeSuite(test, context=test.context))
  520.             else:
  521.                 wrapped.append(
  522.                     Test(test, config=self.config, resultProxy=self.resultProxy)
  523.                     )
  524.         return wrapped
  525.  
  526.  
  527. class ContextList(object):
  528.     """Not quite a suite -- a group of tests in a context. This is used
  529.     to hint the ContextSuiteFactory about what context the tests
  530.     belong to, in cases where it may be ambiguous or missing.
  531.     """
  532.     def __init__(self, tests, context=None):
  533.         self.tests = tests
  534.         self.context = context
  535.  
  536.     def __iter__(self):
  537.         return iter(self.tests)
  538.  
  539.  
  540. class FinalizingSuiteWrapper(unittest.TestSuite):
  541.     """Wraps suite and calls final function after suite has
  542.     executed. Used to call final functions in cases (like running in
  543.     the standard test runner) where test running is not under nose's
  544.     control.    
  545.     """
  546.     def __init__(self, suite, finalize):
  547.         self.suite = suite
  548.         self.finalize = finalize
  549.  
  550.     def __call__(self, *arg, **kw):
  551.         return self.run(*arg, **kw)
  552.  
  553.     def run(self, *arg, **kw):
  554.         try:
  555.             return self.suite(*arg, **kw)
  556.         finally:
  557.             self.finalize(*arg, **kw)
  558.  
  559.  
  560. # backwards compat -- sort of
  561. class TestDir:
  562.     def __init__(*arg, **kw):
  563.         raise NotImplementedError(
  564.             "TestDir is not usable with nose 0.10. The class is present "
  565.             "in nose.suite for backwards compatibility purposes but it "
  566.             "may not be used.")
  567.  
  568.  
  569. class TestModule:
  570.     def __init__(*arg, **kw):
  571.         raise NotImplementedError(
  572.             "TestModule is not usable with nose 0.10. The class is present "
  573.             "in nose.suite for backwards compatibility purposes but it "
  574.             "may not be used.")
  575.